/*
** Lua binding: ppl
** Generated automatically by tolua++-1.0.92 on 01/26/14 20:17:31.
*/

#ifndef __cplusplus
#include "stdlib.h"
#endif
#include "string.h"

#include "tolua++.h"

/* Exported function */
TOLUA_API int  tolua_ppl_open (lua_State* tolua_S);

#include "luaPPL.h"
/* function to release collected object via destructor */
#ifdef __cplusplus

static int tolua_collect_CCPoint (lua_State* tolua_S)
{
 CCPoint* self = (CCPoint*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}
#endif


/* function to register type */
static void tolua_reg_types (lua_State* tolua_S)
{
#ifndef Mtolua_typeid
#define Mtolua_typeid(L,TI,T)
#endif
 tolua_usertype(tolua_S,"CCPoint");
 Mtolua_typeid(tolua_S,typeid(CCPoint), "CCPoint");
 tolua_usertype(tolua_S,"CCSize");
 Mtolua_typeid(tolua_S,typeid(CCSize), "CCSize");
 tolua_usertype(tolua_S,"pplData");
 Mtolua_typeid(tolua_S,typeid(pplData), "pplData");
 tolua_usertype(tolua_S,"stShootReturn");
 Mtolua_typeid(tolua_S,typeid(stShootReturn), "stShootReturn");
 tolua_usertype(tolua_S,"stBubble");
 Mtolua_typeid(tolua_S,typeid(stBubble), "stBubble");
}

/* function: PointDis2 */
#ifndef TOLUA_DISABLE_tolua_ppl_PointDis200
static int tolua_ppl_PointDis200(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     (tolua_isvaluenil(tolua_S,1,&tolua_err) || !tolua_isusertype(tolua_S,1,"CCPoint",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"CCPoint",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  CCPoint pt1 = *((CCPoint*)  tolua_tousertype(tolua_S,1,0));
  CCPoint pt2 = *((CCPoint*)  tolua_tousertype(tolua_S,2,0));
  {
   float tolua_ret = (float)  PointDis2(pt1,pt2);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'PointDis2'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* get function: eType of class  stBubble */
#ifndef TOLUA_DISABLE_tolua_get_stBubble_eType
static int tolua_get_stBubble_eType(lua_State* tolua_S)
{
  stBubble* self = (stBubble*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'eType'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->eType);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: eType of class  stBubble */
#ifndef TOLUA_DISABLE_tolua_set_stBubble_eType
static int tolua_set_stBubble_eType(lua_State* tolua_S)
{
  stBubble* self = (stBubble*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'eType'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->eType = ((BubbleType) (int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: color of class  stBubble */
#ifndef TOLUA_DISABLE_tolua_get_stBubble_color
static int tolua_get_stBubble_color(lua_State* tolua_S)
{
  stBubble* self = (stBubble*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'color'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->color);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: color of class  stBubble */
#ifndef TOLUA_DISABLE_tolua_set_stBubble_color
static int tolua_set_stBubble_color(lua_State* tolua_S)
{
  stBubble* self = (stBubble*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'color'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->color = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: bLink of class  stBubble */
#ifndef TOLUA_DISABLE_tolua_get_stBubble_bLink
static int tolua_get_stBubble_bLink(lua_State* tolua_S)
{
  stBubble* self = (stBubble*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'bLink'",NULL);
#endif
  tolua_pushboolean(tolua_S,(bool)self->bLink);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: bLink of class  stBubble */
#ifndef TOLUA_DISABLE_tolua_set_stBubble_bLink
static int tolua_set_stBubble_bLink(lua_State* tolua_S)
{
  stBubble* self = (stBubble*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'bLink'",NULL);
  if (!tolua_isboolean(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->bLink = ((bool)  tolua_toboolean(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: bWaitingDrop of class  stBubble */
#ifndef TOLUA_DISABLE_tolua_get_stBubble_bWaitingDrop
static int tolua_get_stBubble_bWaitingDrop(lua_State* tolua_S)
{
  stBubble* self = (stBubble*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'bWaitingDrop'",NULL);
#endif
  tolua_pushboolean(tolua_S,(bool)self->bWaitingDrop);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: bWaitingDrop of class  stBubble */
#ifndef TOLUA_DISABLE_tolua_set_stBubble_bWaitingDrop
static int tolua_set_stBubble_bWaitingDrop(lua_State* tolua_S)
{
  stBubble* self = (stBubble*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'bWaitingDrop'",NULL);
  if (!tolua_isboolean(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->bWaitingDrop = ((bool)  tolua_toboolean(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsNull of class  stBubble */
#ifndef TOLUA_DISABLE_tolua_ppl_stBubble_IsNull00
static int tolua_ppl_stBubble_IsNull00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"stBubble",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  stBubble* self = (stBubble*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsNull'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->IsNull();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsNull'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* get function: bOK of class  stShootReturn */
#ifndef TOLUA_DISABLE_tolua_get_stShootReturn_bOK
static int tolua_get_stShootReturn_bOK(lua_State* tolua_S)
{
  stShootReturn* self = (stShootReturn*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'bOK'",NULL);
#endif
  tolua_pushboolean(tolua_S,(bool)self->bOK);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: bOK of class  stShootReturn */
#ifndef TOLUA_DISABLE_tolua_set_stShootReturn_bOK
static int tolua_set_stShootReturn_bOK(lua_State* tolua_S)
{
  stShootReturn* self = (stShootReturn*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'bOK'",NULL);
  if (!tolua_isboolean(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->bOK = ((bool)  tolua_toboolean(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: ptQie of class  stShootReturn */
#ifndef TOLUA_DISABLE_tolua_get_stShootReturn_ptQie
static int tolua_get_stShootReturn_ptQie(lua_State* tolua_S)
{
  stShootReturn* self = (stShootReturn*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'ptQie'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->ptQie,"CCPoint");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: ptQie of class  stShootReturn */
#ifndef TOLUA_DISABLE_tolua_set_stShootReturn_ptQie
static int tolua_set_stShootReturn_ptQie(lua_State* tolua_S)
{
  stShootReturn* self = (stShootReturn*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'ptQie'",NULL);
  if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"CCPoint",0,&tolua_err)))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->ptQie = *((CCPoint*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: selectR of class  stShootReturn */
#ifndef TOLUA_DISABLE_tolua_get_stShootReturn_selectR
static int tolua_get_stShootReturn_selectR(lua_State* tolua_S)
{
  stShootReturn* self = (stShootReturn*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'selectR'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->selectR);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: selectR of class  stShootReturn */
#ifndef TOLUA_DISABLE_tolua_set_stShootReturn_selectR
static int tolua_set_stShootReturn_selectR(lua_State* tolua_S)
{
  stShootReturn* self = (stShootReturn*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'selectR'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->selectR = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: selectC of class  stShootReturn */
#ifndef TOLUA_DISABLE_tolua_get_stShootReturn_selectC
static int tolua_get_stShootReturn_selectC(lua_State* tolua_S)
{
  stShootReturn* self = (stShootReturn*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'selectC'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->selectC);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: selectC of class  stShootReturn */
#ifndef TOLUA_DISABLE_tolua_set_stShootReturn_selectC
static int tolua_set_stShootReturn_selectC(lua_State* tolua_S)
{
  stShootReturn* self = (stShootReturn*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'selectC'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->selectC = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: finalR of class  stShootReturn */
#ifndef TOLUA_DISABLE_tolua_get_stShootReturn_finalR
static int tolua_get_stShootReturn_finalR(lua_State* tolua_S)
{
  stShootReturn* self = (stShootReturn*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'finalR'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->finalR);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: finalR of class  stShootReturn */
#ifndef TOLUA_DISABLE_tolua_set_stShootReturn_finalR
static int tolua_set_stShootReturn_finalR(lua_State* tolua_S)
{
  stShootReturn* self = (stShootReturn*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'finalR'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->finalR = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: finalC of class  stShootReturn */
#ifndef TOLUA_DISABLE_tolua_get_stShootReturn_finalC
static int tolua_get_stShootReturn_finalC(lua_State* tolua_S)
{
  stShootReturn* self = (stShootReturn*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'finalC'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->finalC);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: finalC of class  stShootReturn */
#ifndef TOLUA_DISABLE_tolua_set_stShootReturn_finalC
static int tolua_set_stShootReturn_finalC(lua_State* tolua_S)
{
  stShootReturn* self = (stShootReturn*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'finalC'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->finalC = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* method: sharedPplData of class  pplData */
#ifndef TOLUA_DISABLE_tolua_ppl_pplData_sharedPplData00
static int tolua_ppl_pplData_sharedPplData00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"pplData",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   pplData* tolua_ret = (pplData*)  pplData::sharedPplData();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"pplData");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'sharedPplData'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetBubbleR of class  pplData */
#ifndef TOLUA_DISABLE_tolua_ppl_pplData_SetBubbleR00
static int tolua_ppl_pplData_SetBubbleR00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"pplData",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  pplData* self = (pplData*)  tolua_tousertype(tolua_S,1,0);
  float r = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetBubbleR'", NULL);
#endif
  {
   self->SetBubbleR(r);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetBubbleR'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetBubbleR of class  pplData */
#ifndef TOLUA_DISABLE_tolua_ppl_pplData_GetBubbleR00
static int tolua_ppl_pplData_GetBubbleR00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"pplData",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  pplData* self = (pplData*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetBubbleR'", NULL);
#endif
  {
   float tolua_ret = (float)  self->GetBubbleR();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetBubbleR'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetRowDis of class  pplData */
#ifndef TOLUA_DISABLE_tolua_ppl_pplData_SetRowDis00
static int tolua_ppl_pplData_SetRowDis00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"pplData",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  pplData* self = (pplData*)  tolua_tousertype(tolua_S,1,0);
  float f = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetRowDis'", NULL);
#endif
  {
   self->SetRowDis(f);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetRowDis'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetFirstRowPoint of class  pplData */
#ifndef TOLUA_DISABLE_tolua_ppl_pplData_SetFirstRowPoint00
static int tolua_ppl_pplData_SetFirstRowPoint00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"pplData",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"CCPoint",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  pplData* self = (pplData*)  tolua_tousertype(tolua_S,1,0);
  CCPoint pt = *((CCPoint*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetFirstRowPoint'", NULL);
#endif
  {
   self->SetFirstRowPoint(pt);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetFirstRowPoint'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetFirstRowPoint of class  pplData */
#ifndef TOLUA_DISABLE_tolua_ppl_pplData_GetFirstRowPoint00
static int tolua_ppl_pplData_GetFirstRowPoint00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"pplData",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  pplData* self = (pplData*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetFirstRowPoint'", NULL);
#endif
  {
   CCPoint tolua_ret = (CCPoint)  self->GetFirstRowPoint();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((CCPoint)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"CCPoint");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CCPoint));
     tolua_pushusertype(tolua_S,tolua_obj,"CCPoint");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetFirstRowPoint'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetRowY of class  pplData */
#ifndef TOLUA_DISABLE_tolua_ppl_pplData_GetRowY00
static int tolua_ppl_pplData_GetRowY00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"pplData",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  pplData* self = (pplData*)  tolua_tousertype(tolua_S,1,0);
  int r = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetRowY'", NULL);
#endif
  {
   float tolua_ret = (float)  self->GetRowY(r);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetRowY'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetColumnX of class  pplData */
#ifndef TOLUA_DISABLE_tolua_ppl_pplData_GetColumnX00
static int tolua_ppl_pplData_GetColumnX00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"pplData",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  pplData* self = (pplData*)  tolua_tousertype(tolua_S,1,0);
  int r = ((int)  tolua_tonumber(tolua_S,2,0));
  int c = ((int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetColumnX'", NULL);
#endif
  {
   float tolua_ret = (float)  self->GetColumnX(r,c);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetColumnX'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetYUp of class  pplData */
#ifndef TOLUA_DISABLE_tolua_ppl_pplData_SetYUp00
static int tolua_ppl_pplData_SetYUp00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"pplData",0,&tolua_err) ||
     !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  pplData* self = (pplData*)  tolua_tousertype(tolua_S,1,0);
  bool b = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetYUp'", NULL);
#endif
  {
   self->SetYUp(b);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetYUp'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsYUp of class  pplData */
#ifndef TOLUA_DISABLE_tolua_ppl_pplData_IsYUp00
static int tolua_ppl_pplData_IsYUp00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"pplData",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  pplData* self = (pplData*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsYUp'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->IsYUp();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsYUp'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetBubbleCenter of class  pplData */
#ifndef TOLUA_DISABLE_tolua_ppl_pplData_GetBubbleCenter00
static int tolua_ppl_pplData_GetBubbleCenter00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"pplData",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  pplData* self = (pplData*)  tolua_tousertype(tolua_S,1,0);
  int r = ((int)  tolua_tonumber(tolua_S,2,0));
  int c = ((int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetBubbleCenter'", NULL);
#endif
  {
   CCPoint tolua_ret = (CCPoint)  self->GetBubbleCenter(r,c);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((CCPoint)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"CCPoint");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CCPoint));
     tolua_pushusertype(tolua_S,tolua_obj,"CCPoint");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetBubbleCenter'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: ClearAllBubbles of class  pplData */
#ifndef TOLUA_DISABLE_tolua_ppl_pplData_ClearAllBubbles00
static int tolua_ppl_pplData_ClearAllBubbles00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"pplData",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  pplData* self = (pplData*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ClearAllBubbles'", NULL);
#endif
  {
   self->ClearAllBubbles();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'ClearAllBubbles'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetBubble of class  pplData */
#ifndef TOLUA_DISABLE_tolua_ppl_pplData_SetBubble00
static int tolua_ppl_pplData_SetBubble00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"pplData",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  pplData* self = (pplData*)  tolua_tousertype(tolua_S,1,0);
  int r = ((int)  tolua_tonumber(tolua_S,2,0));
  int c = ((int)  tolua_tonumber(tolua_S,3,0));
  BubbleType eType = ((BubbleType) (int)  tolua_tonumber(tolua_S,4,0));
  int color = ((int)  tolua_tonumber(tolua_S,5,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetBubble'", NULL);
#endif
  {
   self->SetBubble(r,c,eType,color);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetBubble'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: DeleteBubble of class  pplData */
#ifndef TOLUA_DISABLE_tolua_ppl_pplData_DeleteBubble00
static int tolua_ppl_pplData_DeleteBubble00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"pplData",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  pplData* self = (pplData*)  tolua_tousertype(tolua_S,1,0);
  int r = ((int)  tolua_tonumber(tolua_S,2,0));
  int c = ((int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'DeleteBubble'", NULL);
#endif
  {
   self->DeleteBubble(r,c);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'DeleteBubble'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetBubblePure of class  pplData */
#ifndef TOLUA_DISABLE_tolua_ppl_pplData_GetBubblePure00
static int tolua_ppl_pplData_GetBubblePure00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"pplData",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  pplData* self = (pplData*)  tolua_tousertype(tolua_S,1,0);
  int r = ((int)  tolua_tonumber(tolua_S,2,0));
  int c = ((int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetBubblePure'", NULL);
#endif
  {
   stBubble* tolua_ret = (stBubble*)  self->GetBubblePure(r,c);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"stBubble");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetBubblePure'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: DeleteRowData of class  pplData */
#ifndef TOLUA_DISABLE_tolua_ppl_pplData_DeleteRowData00
static int tolua_ppl_pplData_DeleteRowData00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"pplData",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  pplData* self = (pplData*)  tolua_tousertype(tolua_S,1,0);
  int r = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'DeleteRowData'", NULL);
#endif
  {
   self->DeleteRowData(r);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'DeleteRowData'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: DeleteLowestRow of class  pplData */
#ifndef TOLUA_DISABLE_tolua_ppl_pplData_DeleteLowestRow00
static int tolua_ppl_pplData_DeleteLowestRow00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"pplData",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  pplData* self = (pplData*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'DeleteLowestRow'", NULL);
#endif
  {
   self->DeleteLowestRow();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'DeleteLowestRow'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetShootBubble of class  pplData */
#ifndef TOLUA_DISABLE_tolua_ppl_pplData_SetShootBubble00
static int tolua_ppl_pplData_SetShootBubble00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"pplData",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  pplData* self = (pplData*)  tolua_tousertype(tolua_S,1,0);
  BubbleType eType = ((BubbleType) (int)  tolua_tonumber(tolua_S,2,0));
  int color = ((int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetShootBubble'", NULL);
#endif
  {
   self->SetShootBubble(eType,color);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetShootBubble'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetShootBubble of class  pplData */
#ifndef TOLUA_DISABLE_tolua_ppl_pplData_GetShootBubble00
static int tolua_ppl_pplData_GetShootBubble00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"pplData",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  pplData* self = (pplData*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetShootBubble'", NULL);
#endif
  {
   stBubble* tolua_ret = (stBubble*)  self->GetShootBubble();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"stBubble");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetShootBubble'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: DeleteShootBubble of class  pplData */
#ifndef TOLUA_DISABLE_tolua_ppl_pplData_DeleteShootBubble00
static int tolua_ppl_pplData_DeleteShootBubble00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"pplData",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  pplData* self = (pplData*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'DeleteShootBubble'", NULL);
#endif
  {
   self->DeleteShootBubble();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'DeleteShootBubble'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetLREdgeX of class  pplData */
#ifndef TOLUA_DISABLE_tolua_ppl_pplData_SetLREdgeX00
static int tolua_ppl_pplData_SetLREdgeX00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"pplData",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  pplData* self = (pplData*)  tolua_tousertype(tolua_S,1,0);
  float fLeftX = ((float)  tolua_tonumber(tolua_S,2,0));
  float fRightX = ((float)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetLREdgeX'", NULL);
#endif
  {
   self->SetLREdgeX(fLeftX,fRightX);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetLREdgeX'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetScreenSize of class  pplData */
#ifndef TOLUA_DISABLE_tolua_ppl_pplData_SetScreenSize00
static int tolua_ppl_pplData_SetScreenSize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"pplData",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"CCSize",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  pplData* self = (pplData*)  tolua_tousertype(tolua_S,1,0);
  CCSize szScreen = *((CCSize*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetScreenSize'", NULL);
#endif
  {
   self->SetScreenSize(szScreen);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetScreenSize'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: DebugOuput of class  pplData */
#ifndef TOLUA_DISABLE_tolua_ppl_pplData_DebugOuput00
static int tolua_ppl_pplData_DebugOuput00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"pplData",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  pplData* self = (pplData*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'DebugOuput'", NULL);
#endif
  {
   self->DebugOuput();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'DebugOuput'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* Open function */
TOLUA_API int tolua_ppl_open (lua_State* tolua_S)
{
 tolua_open(tolua_S);
 tolua_reg_types(tolua_S);
 tolua_module(tolua_S,NULL,0);
 tolua_beginmodule(tolua_S,NULL);
  tolua_function(tolua_S,"PointDis2",tolua_ppl_PointDis200);
  tolua_constant(tolua_S,"Bubble_Null",Bubble_Null);
  tolua_constant(tolua_S,"Bubble_Fixed",Bubble_Fixed);
  tolua_constant(tolua_S,"Bubble_Color",Bubble_Color);
  tolua_constant(tolua_S,"Bubble_MultiColor",Bubble_MultiColor);
  tolua_constant(tolua_S,"Bubble_NoColor",Bubble_NoColor);
  tolua_cclass(tolua_S,"stBubble","stBubble","",NULL);
  tolua_beginmodule(tolua_S,"stBubble");
   tolua_variable(tolua_S,"eType",tolua_get_stBubble_eType,tolua_set_stBubble_eType);
   tolua_variable(tolua_S,"color",tolua_get_stBubble_color,tolua_set_stBubble_color);
   tolua_variable(tolua_S,"bLink",tolua_get_stBubble_bLink,tolua_set_stBubble_bLink);
   tolua_variable(tolua_S,"bWaitingDrop",tolua_get_stBubble_bWaitingDrop,tolua_set_stBubble_bWaitingDrop);
   tolua_function(tolua_S,"IsNull",tolua_ppl_stBubble_IsNull00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"stShootReturn","stShootReturn","",NULL);
  tolua_beginmodule(tolua_S,"stShootReturn");
   tolua_variable(tolua_S,"bOK",tolua_get_stShootReturn_bOK,tolua_set_stShootReturn_bOK);
   tolua_variable(tolua_S,"ptQie",tolua_get_stShootReturn_ptQie,tolua_set_stShootReturn_ptQie);
   tolua_variable(tolua_S,"selectR",tolua_get_stShootReturn_selectR,tolua_set_stShootReturn_selectR);
   tolua_variable(tolua_S,"selectC",tolua_get_stShootReturn_selectC,tolua_set_stShootReturn_selectC);
   tolua_variable(tolua_S,"finalR",tolua_get_stShootReturn_finalR,tolua_set_stShootReturn_finalR);
   tolua_variable(tolua_S,"finalC",tolua_get_stShootReturn_finalC,tolua_set_stShootReturn_finalC);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"pplData","pplData","",NULL);
  tolua_beginmodule(tolua_S,"pplData");
   tolua_function(tolua_S,"sharedPplData",tolua_ppl_pplData_sharedPplData00);
   tolua_function(tolua_S,"SetBubbleR",tolua_ppl_pplData_SetBubbleR00);
   tolua_function(tolua_S,"GetBubbleR",tolua_ppl_pplData_GetBubbleR00);
   tolua_function(tolua_S,"SetRowDis",tolua_ppl_pplData_SetRowDis00);
   tolua_function(tolua_S,"SetFirstRowPoint",tolua_ppl_pplData_SetFirstRowPoint00);
   tolua_function(tolua_S,"GetFirstRowPoint",tolua_ppl_pplData_GetFirstRowPoint00);
   tolua_function(tolua_S,"GetRowY",tolua_ppl_pplData_GetRowY00);
   tolua_function(tolua_S,"GetColumnX",tolua_ppl_pplData_GetColumnX00);
   tolua_function(tolua_S,"SetYUp",tolua_ppl_pplData_SetYUp00);
   tolua_function(tolua_S,"IsYUp",tolua_ppl_pplData_IsYUp00);
   tolua_function(tolua_S,"GetBubbleCenter",tolua_ppl_pplData_GetBubbleCenter00);
   tolua_function(tolua_S,"ClearAllBubbles",tolua_ppl_pplData_ClearAllBubbles00);
   tolua_function(tolua_S,"SetBubble",tolua_ppl_pplData_SetBubble00);
   tolua_function(tolua_S,"DeleteBubble",tolua_ppl_pplData_DeleteBubble00);
   tolua_function(tolua_S,"GetBubblePure",tolua_ppl_pplData_GetBubblePure00);
   tolua_function(tolua_S,"DeleteRowData",tolua_ppl_pplData_DeleteRowData00);
   tolua_function(tolua_S,"DeleteLowestRow",tolua_ppl_pplData_DeleteLowestRow00);
   tolua_function(tolua_S,"SetShootBubble",tolua_ppl_pplData_SetShootBubble00);
   tolua_function(tolua_S,"GetShootBubble",tolua_ppl_pplData_GetShootBubble00);
   tolua_function(tolua_S,"DeleteShootBubble",tolua_ppl_pplData_DeleteShootBubble00);
   tolua_function(tolua_S,"SetLREdgeX",tolua_ppl_pplData_SetLREdgeX00);
   tolua_function(tolua_S,"SetScreenSize",tolua_ppl_pplData_SetScreenSize00);
   tolua_function(tolua_S,"DebugOuput",tolua_ppl_pplData_DebugOuput00);
  tolua_endmodule(tolua_S);
 tolua_endmodule(tolua_S);
 return 1;
}


#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 501
 TOLUA_API int luaopen_ppl (lua_State* tolua_S) {
 return tolua_ppl_open(tolua_S);
};
#endif

